/**
 * 剪贴板管理模块
 * 负责管理剪贴板历史记录，提供复制、粘贴和收藏功能
 */

const { clipboard, } = require('electron');
//剪切板管理
// 状态管理
let state = {
    clipboardHistory: [],
    currentFilter: 'all',
    searchTerm: '',
    selectedItem: null,
    settings: {
        autoMonitor: true,
        maxItems: 100,           // 最大记录数
        keepStarred: true,       // 保留已标记项目
        cleanupRules: {
            enabled: false,      // 是否启用自动清理
            interval: 7,         // 自动清理间隔（天）
            maxAge: 30,         // 最大保留天数
            maxSize: 10,        // 最大文件大小（MB）
            excludeTypes: [],    // 不清理的类型列表
            smartClean: {        // 智能清理规则
                enabled: true,   // 是否启用智能清理
                duplicates: true, // 清理重复内容
                emptyContent: true, // 清理空内容
                oversizeByType: { // 按类型设置大小限制
                    text: 1,     // 文本 1MB
                    link: 0.1,   // 链接 0.1MB
                    image: 5,    // 图片 5MB
                    file: 10     // 文件 10MB
                }
            }
        }
    },
    editingItem: null,
    pinnedItems: new Set()
};
let isInitialized = false;
function initialize() {
    console.log('剪贴板管理模块初始化');
    if (isInitialized) {
        //刷新
        updateClipboardList();
        return;
    }
    loadSettings();
    initializeEventListeners();// 初始化事件监听器
    startClipboardMonitor();
    startAutoCleanup();
    updateClipboardList();
    isInitialized = true;
    console.log('剪贴板管理模块初始化完成', state);
}
// // 初始化
// document.addEventListener('DOMContentLoaded', () => {
//     loadSettings();
//     initializeEventListeners();
//     startClipboardMonitor();
//     startAutoCleanup();
//     updateClipboardList();
// });

// 加载设置
function loadSettings() {
    try {
        // 默认设置
        const defaultSettings = {
            autoMonitor: true,
            maxItems: 100,
            keepStarred: true,
            cleanupRules: {
                enabled: false,
                interval: 7,
                maxAge: 30,
                maxSize: 10,
                excludeTypes: [],
                smartClean: {
                    enabled: true,
                    duplicates: true,
                    emptyContent: true,
                    oversizeByType: {
                        text: 1,
                        link: 0.1,
                        image: 5,
                        file: 10
                    }
                }
            }
        };

        // 从本地存储加载设置
        const savedSettings = localStorage.getItem('clipboard_settings');
        if (savedSettings) {
            try {
                const parsed = JSON.parse(savedSettings);
                // 深度合并设置，确保所有必需的属性都存在
                state.settings = deepMerge(defaultSettings, parsed);
            } catch (parseErr) {
                console.error('解析保存的设置失败:', parseErr);
                state.settings = defaultSettings;
            }
        } else {
            state.settings = defaultSettings;
        }

        // 设置自动监听开关状态
        const autoMonitorToggle = document.getElementById('auto-monitor-toggle');
        if (autoMonitorToggle) {
            autoMonitorToggle.checked = state.settings.autoMonitor;
        }

        // 加载置顶项目
        const savedPinnedItems = localStorage.getItem('clipboard_pinned_items');
        if (savedPinnedItems) {
            try {
                state.pinnedItems = new Set(JSON.parse(savedPinnedItems));
            } catch (parseErr) {
                console.error('解析置顶项目失败:', parseErr);
                state.pinnedItems = new Set();
            }
        }

        // 加载剪贴板历史记录
        const savedHistory = localStorage.getItem('clipboard_history');
        if (savedHistory) {
            try {
                state.clipboardHistory = JSON.parse(savedHistory);
                //starred状态true的置顶
                state.clipboardHistory.forEach(item => {
                    if (item.starred) {
                        state.pinnedItems.add(item.id);
                    }
                })
            } catch (parseErr) {
                console.error('解析历史记录失败:', parseErr);
                state.clipboardHistory = [];
            }
        }

        console.log('设置加载完成');
    } catch (err) {
        console.error('加载设置时出错:', err);
        showToast('加载设置时出现错误，已使用默认设置', 'error');
    }
}

// 深度合并对象
function deepMerge(target, source) {
    const result = { ...target };

    for (const key in source) {
        if (source[key] instanceof Object && !Array.isArray(source[key])) {
            if (key in target) {
                result[key] = deepMerge(target[key], source[key]);
            } else {
                result[key] = { ...source[key] };
            }
        } else {
            result[key] = source[key];
        }
    }

    return result;
}

// 修改saveSettings函数确保正确保存所有设置
function saveSettings() {
    try {
        // 保存基本设置
        localStorage.setItem('clipboard_settings', JSON.stringify(state.settings));

        // 保存置顶项目
        localStorage.setItem('clipboard_pinned_items', JSON.stringify([...state.pinnedItems]));

        // 保存剪贴板历史记录
        // 获取已存储的历史记录
        const existingHistory = localStorage.getItem('clipboard_history');
        let updatedHistory = [];

        if (existingHistory) {
            try {
                const parsedHistory = JSON.parse(existingHistory);
                // 创建一个Map用于快速查找现有内容
                const existingMap = new Map(parsedHistory.map(item => [item.content, item]));

                // 遍历当前历史记录
                state.clipboardHistory.forEach(item => {
                    const existingItem = existingMap.get(item.content);
                    if (existingItem) {
                        // 如果内容已存在，使用已存在的记录但更新时间戳,并放在最前面
                        // 但保留已标记状态
                        updatedHistory.unshift({
                            ...existingItem,
                            timestamp: item.timestamp,
                            starred: item.starred
                        });
                    } else {
                        // 如果是新内容，直接添加
                        if (item.content && item.content.length > 0) {
                            updatedHistory.push(item);
                        }
                    }
                });

                // 添加本地存储中独有的记录
                parsedHistory.forEach(item => {
                    if (!state.clipboardHistory.some(current => current.content === item.content)) {
                        // 如果是新内容，直接添加
                        if (item.content && item.content.length > 0) {
                            updatedHistory.push(item);
                        }
                    }
                });
            } catch (err) {
                console.error('解析已存储的历史记录失败:', err);
                updatedHistory = state.clipboardHistory;
            }
        } else {
            updatedHistory = state.clipboardHistory;
        }

        // 更新state中的历史记录并保存到localStorage
        state.clipboardHistory = updatedHistory;
        localStorage.setItem('clipboard_history', JSON.stringify(updatedHistory));
        console.log('设置已保存:', state.settings);
    } catch (err) {
        console.error('保存设置时出错:', err);
        showToast('保存设置时出现错误', 'error');
    }
}

// 剪贴板监听
let clipboardMonitor = null;
let isPageFocused = document.hasFocus();

// 监听页面焦点变化
document.addEventListener('visibilitychange', () => {
    // 只有当文档真正隐藏时才更改焦点状态
    // 菜单切换不应该触发此事件
    if (document.hidden) {
        isPageFocused = false;
    } else {
        isPageFocused = true;
    }
});
// 监听窗口焦点变化
window.addEventListener('focus', () => {
    isPageFocused = true;
});
// 监听窗口失去焦点 - 添加判断以防止菜单切换误触发
window.addEventListener('blur', (event) => {
    // 检查是否是真正的窗口失焦，而不是菜单切换
    // 如果relatedTarget存在，说明焦点只是在窗口内部元素间转移
    if (!event.relatedTarget) {
        isPageFocused = false;
    }
});
//开始监听剪贴板
function startClipboardMonitor() {
    // 检查剪贴板监听是否已启动
    if (!clipboardMonitor && state.settings.autoMonitor) {
        const checkInterval = 1000; // 2秒检查一次

        // 保存监听器引用，以便后续可以正确停止
        clipboardMonitor = setInterval(() => {
            checkClipboard();
        }, checkInterval);
        // 页面加载时尝试请求剪贴板权限
        requestClipboardPermission();

        console.log('剪贴板监听已启动');
    }
}
// 停止监听剪贴板
function stopClipboardMonitor() {
    if (clipboardMonitor) {
        clearInterval(clipboardMonitor);
        clipboardMonitor = null;
    }
}

// 请求剪贴板权限
async function requestClipboardPermission() {
    try {
        // 尝试请求剪贴板读取权限
        const [clipboardRead, clipboardWrite] = await Promise.all([
            navigator.permissions.query({ name: 'clipboard-read' }),
            navigator.permissions.query({ name: 'clipboard-write' })
        ]);

        if (clipboardRead.state === 'denied' || clipboardWrite.state === 'denied') {
            showToast('需要完整的剪贴板访问权限才能自动监听', 'error');

            return;
        }

        // 测试剪贴板API是否可用
        try {
            await navigator.clipboard.read();
        } catch (err) {
            if (err.name === 'NotAllowedError') {
                showToast('请在浏览器弹窗中允许访问剪贴板', 'info');
            }
        }
    } catch (err) {
        console.log('不支持剪贴板权限查询:', err);
        // 尝试使用基本的读取功能
        try {
            await navigator.clipboard.readText();
        } catch (textErr) {
            if (textErr.name === 'NotAllowedError') {
                showToast('请在浏览器弹窗中允许访问剪贴板', 'info');
            }
        }
    }
}

async function checkClipboard() {
    // 检查页面焦点状态，但允许菜单切换时继续监听
    // 注释掉的代码保留作为参考
    // if (!isPageFocused) {
    //     console.info('页面未获得焦点，跳过剪贴板检查',new Date().toISOString());
    // }

    try {
        // 尝试读取剪贴板中的所有可用格式
        const clipboardItems = await navigator.clipboard.read();

        for (const clipboardItem of clipboardItems) {
            // 处理图片
            if (clipboardItem.types.includes('image/png') ||
                clipboardItem.types.includes('image/jpeg') ||
                clipboardItem.types.includes('image/gif') ||
                clipboardItem.types.includes('image/webp')) {

                // 获取图片blob
                const imageType = clipboardItem.types.find(type => type.startsWith('image/'));
                const blob = await clipboardItem.getType(imageType);

                // 转换为Base64
                const reader = new FileReader();
                reader.onload = function (e) {
                    const imageData = e.target.result;
                    // 检查是否已存在相同的图片
                    if (!state.clipboardHistory.some(item => item.content === imageData)) {
                        addToHistory(imageData);
                    }
                };
                reader.readAsDataURL(blob);
                return;
            }

            // 处理文本
            if (clipboardItem.types.includes('text/plain')) {
                const text = await (await clipboardItem.getType('text/plain')).text();
                if (text && !state.clipboardHistory.some(item => item.content === text)) {
                    addToHistory(text.trim());
                } else {
                    //更新时间戳
                    state.clipboardHistory.forEach(item => {
                        if (item.content === text) {
                            item.timestamp = new Date().toISOString();
                        }
                    })
                }
                return;
            }
        }
    } catch (err) {
        // 如果是权限错误，尝试降级到readText方法
        if (err.name === 'NotAllowedError') {
            try {
                const text = await navigator.clipboard.readText();
                if (text && !state.clipboardHistory.some(item => item.content === text)) {
                    addToHistory(text.trim());
                } else {
                    //更新时间戳
                    state.clipboardHistory.forEach(item => {
                        if (item.content === text) {
                            item.timestamp = new Date().toISOString();
                        }
                    })
                }
            } catch (textErr) {
                if (textErr.name === 'NotAllowedError') {
                    // showToast('无法访问剪贴板，请检查浏览器权限设置', 'error');

                } else {
                    console.error('读取剪贴板文本失败:', textErr);
                }
            }
        } else if (err.name === 'SecurityError') {
            // 安全错误，可能是因为页面不在焦点
            console.info('页面未获得焦点，跳过剪贴板检查');
        } else {
            console.error('读取剪贴板失败:', err);
            // showToast('读取剪贴板内容失败', 'error');
        }
    } finally {
        // 无论是否成功，都重置剪贴板
        //如果失去焦点就执行这里
        //失去焦点也要监听剪切板，实现实时读取剪切板
        if (!isPageFocused) {
            //判断剪切板内容类型
            if (clipboard.availableFormats().indexOf('image/png') !== -1) {
                // Step2:读取NativeImage对象  
                const imgObj = clipboard.readImage();

                // Step3:转为Base6 
                if (!imgObj.isEmpty()) {
                    const base6Data = imgObj.toDataURL();
                    if (!state.clipboardHistory.some(item => item.content === base6Data)) {
                        addToHistory(base6Data);
                    }
                }
            } else {
                // 读取文本内容
                const content = clipboard.readText().trim();
                if (content && !state.clipboardHistory.some(item => item.content === content)) {
                    addToHistory(content.trim());
                } else {
                    //更新时间戳
                    state.clipboardHistory.forEach(item => {
                        if (item.content === content) {
                            item.timestamp = new Date().toISOString();
                        }
                    })
                }
            }
        }
    }
}

// 添加到历史记录
function addToHistory(content) {
    /**
     * 检测内容类型
     * @param {string} content 内容
     * @returns {string} 类型
     *starred: 是否置顶
     *size: 大小
     *timestamp: 时间戳
     *type: 类型
     *id: 唯一标识  
     */
    const newItem = {
        id: Date.now(),
        content,
        type: detectContentType(content),
        size: getContentSize(content),
        timestamp: new Date().toISOString(),
        starred: false
    };
    // 添加到历史记录的开头
    state.clipboardHistory.unshift(newItem);

    // 应用最大记录数限制
    if (state.clipboardHistory.length > state.settings.maxItems) {
        const itemsToRemove = state.clipboardHistory
            .slice(state.settings.maxItems)
            .filter(item => !item.starred || !state.settings.keepStarred);
        state.clipboardHistory = [
            ...state.clipboardHistory.slice(0, state.settings.maxItems),
            ...state.clipboardHistory.slice(state.settings.maxItems).filter(item => item.starred && state.settings.keepStarred)
        ];
    }

    saveSettings();
    updateClipboardList();
    showToast('新内容已添加到剪贴板历史');
}

// 检测内容类型
function detectContentType(content) {
    if (!content) return 'text';

    // URL检测
    if (/^https?:\/\/\S+/i.test(content)) return 'link';

    // 图片数据URL
    if (/^data:image\/(jpeg|png|gif|bmp|webp);base64,/.test(content)) return 'image';

    // 文件路径
    if (/\.(pdf|doc|docx|xls|xlsx|txt|json|js|css|html|xml)$/i.test(content)) return 'file';

    return 'text';
}

// 获取内容大小
function getContentSize(content) {
    const bytes = new Blob([content]).size;
    if (bytes < 1024) return bytes + ' B';
    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
    return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
}

// 更新剪贴板列表
function updateClipboardList() {
    const listElement = document.getElementById('clipboard-list');
    const emptyState = document.getElementById('clipboard-empty-state');
    const itemCount = document.getElementById('item-count');

    // 过滤数据
    let filteredItems = state.clipboardHistory;

    if (state.currentFilter !== 'all') {
        filteredItems = filteredItems.filter(item => item.type === state.currentFilter);
    }

    if (state.searchTerm) {
        filteredItems = filteredItems.filter(item =>
            item.content.toLowerCase().includes(state.searchTerm)
        );
    }

    // 分离置顶和非置顶项目
    const pinnedItems = filteredItems
        .filter(item => state.pinnedItems.has(item.id)) //置顶的项目
        .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp)); //按时间戳降序排序
    const unpinnedItems = filteredItems
        .filter(item => !state.pinnedItems.has(item.id)) //非置顶的项目
        .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp)); //按时间戳降序排序

    // 按置顶状态和时间排序
    filteredItems = [...pinnedItems, ...unpinnedItems];

    // 更新UI
    if (filteredItems.length === 0) {
        listElement.style.display = 'none';
        emptyState.style.display = 'block';
    } else {
        listElement.style.display = 'block';
        emptyState.style.display = 'none';

        listElement.innerHTML = filteredItems.map(item => createClipboardItemHTML(item)).join('');

        // 添加事件监听
        listElement.querySelectorAll('.clipboard-item').forEach(element => {
            const id = element.dataset.id;

            // 点击项目
            element.addEventListener('click', () => selectClipboardItem(id));

            // 复制按钮
            element.querySelector('.btn-copy').addEventListener('click', (e) => {
                e.stopPropagation();
                copyContent(id);
            });

            // 编辑按钮
            element.querySelector('.btn-edit').addEventListener('click', (e) => {
                e.stopPropagation();
                startEditing(id);
            });

            // 置顶按钮
            element.querySelector('.btn-pin').addEventListener('click', (e) => {
                e.stopPropagation();
                togglePin(id);
            });

            // 删除按钮
            element.querySelector('.btn-delete').addEventListener('click', (e) => {
                e.stopPropagation();
                deleteContent(id);
            });
        });
    }

    itemCount.textContent = state.clipboardHistory.length;
}


// 创建剪贴板项目HTML
function createClipboardItemHTML(item) {
    const isPinned = state.pinnedItems.has(item.id);
    const date = new Date(item.timestamp);
    const timeString = date.toLocaleString('zh-CN', {
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit'
    });

    return `
        <div class="clipboard-item ${item.id === state.selectedItem?.id ? 'active' : ''} ${isPinned ? 'pinned' : ''}" 
             data-id="${item.id}">
            <div class="item-header">
                <div class="item-type">
                    <i class="fas fa-${getTypeIcon(item.type)}"></i>
                    <span>${getTypeText(item.type)}</span>
                    <span class="item-size">${item.size}</span>
                    ${isPinned ? '<span class="pin-indicator"><i class="fas fa-thumbtack"></i></span>' : ''}
                </div>
                <div class="item-actions">
                    <button class="btn btn-icon btn-copy" title="复制">
                        <i class="fas fa-copy"></i>
                    </button>
                    <button class="btn btn-icon btn-edit" title="编辑">
                        <i class="fas fa-edit"></i>
                    </button>
                    <button class="btn btn-icon btn-pin" title="${isPinned ? '取消置顶' : '置顶'}">
                        <i class="fas fa-thumbtack ${isPinned ? 'active' : ''}"></i>
                    </button>
                    <button class="btn btn-icon btn-delete" title="删除">
                        <i class="fas fa-trash"></i>
                    </button>
                </div>
            </div>
            <div class="item-content">${formatContent(item.content, item.type)}</div>
            <div class="item-footer">
                <div class="item-time">${timeString}</div>
            </div>
        </div>
    `;
}

// 获取类型图标
function getTypeIcon(type) {
    const icons = {
        text: 'font',
        link: 'link',
        image: 'image',
        file: 'file'
    };
    return icons[type] || 'font';
}

// 获取类型文本
function getTypeText(type) {
    const texts = {
        text: '文本',
        link: '链接',
        image: '图片',
        file: '文件'
    };
    return texts[type] || '文本';
}

// 格式化内容
function formatContent(content, type) {
    if (!content) return '';

    const maxLength = 100;
    let formatted = content;

    switch (type) {
        case 'link':
            formatted = `<a href="${content}" target="_blank">${content}</a>`;
            break;
        case 'image':
            formatted = '图片数据';
            break;
        default:
            formatted = content.length > maxLength
                ? content.substring(0, maxLength) + '...'
                : content;
            formatted = escapeHtml(formatted);
    }

    return formatted;
}

// HTML转义
function escapeHtml(text) {
    const div = document.createElement('div');
    div.textContent = text;
    return div.innerHTML;
}

// 选择剪贴板项目
function selectClipboardItem(id) {
    const item = state.clipboardHistory.find(item => item.id.toString() === id);
    if (!item) return;

    state.selectedItem = item;
    updateClipboardList();
    updatePreview(item);
}

// 更新预览
function updatePreview(item) {
    const previewSection = document.getElementById('clipboard-preview');
    const contentInfo = previewSection.querySelector('.content-info');
    const contentTime = previewSection.querySelector('.content-time');
    const previewText = previewSection.querySelector('.preview-text');

    // 更新类型信息
    contentInfo.innerHTML = `
        <i class="fas fa-${getTypeIcon(item.type)}"></i>
        <span>${getTypeText(item.type)}</span>
        <span class="content-size">${item.size}</span>
    `;

    // 更新时间
    const date = new Date(item.timestamp);
    contentTime.textContent = `复制于 ${date.toLocaleString('zh-CN')}`;

    // 更新内容
    previewText.innerHTML = formatPreviewContent(item.content, item.type);
}

// 格式化预览内容
function formatPreviewContent(content, type) {
    switch (type) {
        case 'link':
            return `<a href="${content}" target="_blank">${content}</a>`;
        case 'image':
            if (content.startsWith('data:image')) {
                return `<img src="${content}" alt="剪贴板图片" style="max-width: 100%; height: auto;">`;
            }
            return content;
        default:
            return escapeHtml(content);
    }
}

// 显示设置对话框
function showSettingsModal() {
    try {
        console.log('显示设置对话框...');
        const modal = document.getElementById('settings-modal');
        if (!modal) {
            console.error('未找到设置对话框元素');
            return;
        }

        // 创建或更新设置面板内容
        createOrUpdateSettingsPanel(modal);

        // 显示对话框
        modal.style.display = 'flex';

        // 填充设置值
        updateSettingsValues();

        // 添加动画效果
        modal.classList.add('fade-in');

        // 添加点击外部关闭功能
        modal.addEventListener('click', (e) => {
            if (e.target === modal) {
                hideSettingsModal();
            }
        });

        // 添加ESC键关闭功能
        document.addEventListener('keydown', (e) => {
            if (e.key === 'Escape') {
                hideSettingsModal();
            }
        });

        // 更新预览
        updateCleanupPreview();

        console.log('设置对话框显示完成');
    } catch (err) {
        console.error('显示设置对话框时出错:', err);
        showToast('打开设置失败', 'error');
    }
}

// 创建或更新设置面板内容
function createOrUpdateSettingsPanel(modal) {
    // 检查是否已经存在设置面板
    let settingsPanel = modal.querySelector('.settings-panel');
    if (!settingsPanel) {
        // 添加样式
        const styleElement = document.createElement('style');
        styleElement.textContent = `
            #settings-modal {
                position: fixed;
                top: 0;
                left: 0;
                width: 100%;
                height: 100%;
                background: rgba(0, 0, 0, 0.5);
                display: none;
                justify-content: center;
                align-items: center;
                z-index: 1000;
                backdrop-filter: blur(5px);
            }
            
            .fade-in {
                animation: fadeIn 0.3s ease forwards;
            }
            
            .fade-out {
                animation: fadeOut 0.3s ease forwards;
            }
            
            @keyframes fadeIn {
                from { opacity: 0; }
                to { opacity: 1; }
            }
            
            @keyframes fadeOut {
                from { opacity: 1; }
                to { opacity: 0; }
            }
            
            .settings-panel {
                max-height: 500px;
                width: 90%;
                max-width: 600px;
                overflow-y: auto;
                padding: 20px;
                background: var(--bg-100);
                border-radius: 8px;
                box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
                position: relative;
            }
            
            .settings-panel::-webkit-scrollbar {
                width: 8px;
            }
            
            .settings-panel::-webkit-scrollbar-track {
                background: var(--bg-200);
                border-radius: 4px;
            }
            
            .settings-panel::-webkit-scrollbar-thumb {
                background: var(--text-300);
                border-radius: 4px;
            }
            
            .settings-section {
                margin-bottom: 20px;
                padding: 15px;
                background: var(--bg-200);
                border-radius: 6px;
                transition: all 0.3s ease;
            }
            
            .settings-section:hover {
                transform: translateY(-2px);
                box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
            }
            
            .settings-section h3 {
                margin: 0 0 15px 0;
                color: var(--text-100);
                font-size: 16px;
                font-weight: 600;
                display: flex;
                align-items: center;
                gap: 8px;
            }
            
            .setting-item {
                margin-bottom: 12px;
                padding: 8px;
                border-radius: 4px;
                transition: all 0.2s ease;
            }
            
            .setting-item:hover {
                background: var(--bg-300);
            }
            
            .setting-item label {
                display: flex;
                align-items: center;
                gap: 8px;
                color: var(--text-200);
                cursor: pointer;
            }
            
            .setting-hint {
                margin-left: 8px;
                font-size: 12px;
                color: var(--text-300);
                opacity: 0.8;
                transition: opacity 0.2s ease;
            }
            
            .setting-item:hover .setting-hint {
                opacity: 1;
            }
            
            .small-input {
                width: 80px;
                padding: 4px 8px;
                border: 1px solid var(--border-color);
                border-radius: 4px;
                background: var(--bg-100);
                color: var(--text-100);
                transition: all 0.2s ease;
            }
            
            .small-input:focus {
                border-color: var(--primary-color);
                box-shadow: 0 0 0 2px rgba(var(--primary-rgb), 0.2);
                outline: none;
            }
            
            .type-checkboxes {
                display: grid;
                grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
                gap: 8px;
                margin-top: 8px;
            }
            
            .type-size-limits {
                display: grid;
                grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
                gap: 12px;
                margin-top: 8px;
                padding: 8px;
                background: var(--bg-200);
                border-radius: 4px;
            }
            
            .type-size-item {
                display: flex;
                align-items: center;
                gap: 8px;
                padding: 4px;
                border-radius: 4px;
                transition: all 0.2s ease;
            }
            
            .type-size-item:hover {
                background: var(--bg-300);
            }
            
            .settings-actions {
                margin-top: 20px;
                padding-top: 15px;
                border-top: 1px solid var(--border-color);
                display: flex;
                justify-content: flex-end;
                gap: 10px;
            }
            
            .settings-actions button {
                padding: 8px 16px;
                border: none;
                border-radius: 4px;
                cursor: pointer;
                transition: all 0.2s ease;
                font-weight: 500;
            }
            
            .settings-actions button.primary {
                background: var(--primary-color);
                color: white;
            }
            
            .settings-actions button.secondary {
                background: var(--bg-200);
                color: var(--text-200);
            }
            
            .settings-actions button:hover {
                transform: translateY(-1px);
                box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
            }
            
            .settings-actions button:active {
                transform: translateY(0);
            }
            
            /* 添加开关样式 */
            .switch {
                position: relative;
                display: inline-block;
                width: 40px;
                height: 20px;
            }
            
            .switch input {
                opacity: 0;
                width: 0;
                height: 0;
            }
            
            .slider {
                position: absolute;
                cursor: pointer;
                top: 0;
                left: 0;
                right: 0;
                bottom: 0;
                background-color: var(--bg-300);
                transition: .4s;
                border-radius: 20px;
            }
            
            .slider:before {
                position: absolute;
                content: "";
                height: 16px;
                width: 16px;
                left: 2px;
                bottom: 2px;
                background-color: white;
                transition: .4s;
                border-radius: 50%;
            }
            
            input:checked + .slider {
                background-color: var(--primary-200);
            }
            
            input:checked + .slider:before {
                transform: translateX(20px);
            }
            
            /* 添加输入框动画 */
            @keyframes shake {
                0%, 100% { transform: translateX(0); }
                25% { transform: translateX(-5px); }
                75% { transform: translateX(5px); }
            }
            
            .invalid-input {
                animation: shake 0.3s ease-in-out;
                border-color: var(--error-color) !important;
            }
        `;
        document.head.appendChild(styleElement);

        // 创建设置面板HTML
        const panelHTML = `
            <div class="settings-panel">
                <div class="settings-section">
                    <h3>基本设置</h3>
                    <div class="setting-item">
                        <label for="max-items">最大记录数：</label>
                        <input type="number" id="max-items" min="10" max="1000" step="10">
                    </div>
                    <div class="setting-item">
                        <label for="keep-starred">
                            <input type="checkbox" id="keep-starred">
                            保留已标记项目
                        </label>
                    </div>
                </div>
                
                <div class="settings-section">
                    <h3>清理规则</h3>
                    <div class="setting-item">
                        <label for="cleanup-enabled">
                            <input type="checkbox" id="cleanup-enabled" onchange="updateCleanupSettingsState()">
                            启用自动清理
                        </label>
                    </div>
                    
                    <div id="cleanup-settings-container">
                        <div class="setting-item">
                            <label for="cleanup-interval">自动清理间隔（天）：</label>
                            <input type="number" id="cleanup-interval" min="1" max="365" class="small-input">
                            <span class="setting-hint">设置为0表示仅手动清理</span>
                        </div>
                        <div class="setting-item">
                            <label for="cleanup-max-age">最大保留天数：</label>
                            <input type="number" id="cleanup-max-age" min="1" max="365" class="small-input">
                            <span class="setting-hint">超过此天数的记录将被清理</span>
                        </div>
                        <div class="setting-item">
                            <label for="cleanup-max-size">最大文件大小（MB）：</label>
                            <input type="number" id="cleanup-max-size" min="1" max="100" class="small-input">
                            <span class="setting-hint">超过此大小的记录将被清理</span>
                        </div>
                        
                        <div class="setting-item">
                            <label>排除类型：</label>
                            <div class="type-checkboxes">
                                <label>
                                    <input type="checkbox" class="cleanup-type-checkbox" value="text">
                                    文本
                                </label>
                                <label>
                                    <input type="checkbox" class="cleanup-type-checkbox" value="link">
                                    链接
                                </label>
                                <label>
                                    <input type="checkbox" class="cleanup-type-checkbox" value="image">
                                    图片
                                </label>
                                <label>
                                    <input type="checkbox" class="cleanup-type-checkbox" value="file">
                                    文件
                                </label>
                            </div>
                        </div>

                        <div class="setting-item">
                            <label for="smart-clean-enabled">
                                <input type="checkbox" id="smart-clean-enabled" onchange="updateSmartCleanState()">
                                启用智能清理
                            </label>
                            <span class="setting-hint">自动识别并清理无效内容</span>
                        </div>

                        <div id="smart-clean-settings">
                            <div class="setting-item">
                                <label for="clean-duplicates">
                                    <input type="checkbox" id="clean-duplicates">
                                    清理重复内容
                                </label>
                            </div>
                            <div class="setting-item">
                                <label for="clean-empty">
                                    <input type="checkbox" id="clean-empty">
                                    清理空内容
                                </label>
                            </div>
                            <div class="setting-item">
                                <label>按类型限制大小：</label>
                                <div class="type-size-limits">
                                    <div class="type-size-item">
                                        <label>文本：</label>
                                        <input type="number" id="text-size-limit" min="0.1" max="10" step="0.1" class="small-input">
                                        <span>MB</span>
                                    </div>
                                    <div class="type-size-item">
                                        <label>链接：</label>
                                        <input type="number" id="link-size-limit" min="0.1" max="10" step="0.1" class="small-input">
                                        <span>MB</span>
                                    </div>
                                    <div class="type-size-item">
                                        <label>图片：</label>
                                        <input type="number" id="image-size-limit" min="0.1" max="50" step="0.1" class="small-input">
                                        <span>MB</span>
                                    </div>
                                    <div class="type-size-item">
                                        <label>文件：</label>
                                        <input type="number" id="file-size-limit" min="0.1" max="100" step="0.1" class="small-input">
                                        <span>MB</span>
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>
                
                <div id="cleanup-preview" class="preview-section"></div>
                
                <div class="settings-actions">
                    <button id="save-settings" class="btn btn-primary">保存</button>
                    <button id="cancel-settings" class="btn">取消</button>
                    <button id="clean-now" class="btn btn-warning">立即清理</button>
                </div>
            </div>
        `;

        modal.innerHTML = panelHTML;

        // 绑定事件监听器
        bindSettingsEvents();
    }
}

// 绑定设置面板的事件监听器
function bindSettingsEvents() {
    try {
        console.log('开始绑定设置面板事件...');

        // 保存按钮
        const saveButton = document.getElementById('save-settings');
        if (saveButton) {
            console.log('找到保存按钮，绑定点击事件');
            // 移除可能存在的旧事件监听器
            saveButton.removeEventListener('click', saveSettingsAndClose);
            saveButton.addEventListener('click', saveSettingsAndClose);
        } else {
            console.error('未找到保存按钮');
        }

        // 取消按钮
        const cancelButton = document.getElementById('cancel-settings');
        if (cancelButton) {
            console.log('找到取消按钮，绑定点击事件');
            // 移除可能存在的旧事件监听器
            cancelButton.removeEventListener('click', hideSettingsModal);
            cancelButton.addEventListener('click', hideSettingsModal);
        }

        // 立即清理按钮
        const cleanNowButton = document.getElementById('clean-now');
        if (cleanNowButton) {
            console.log('找到立即清理按钮，绑定点击事件');
            cleanNowButton.removeEventListener('click', handleCleanNow);
            cleanNowButton.addEventListener('click', handleCleanNow);
        }

        // 自动清理开关
        const cleanupEnabled = document.getElementById('cleanup-enabled');
        if (cleanupEnabled) {
            console.log('找到自动清理开关，绑定change事件');
            cleanupEnabled.removeEventListener('change', updateCleanupSettingsState);
            cleanupEnabled.addEventListener('change', updateCleanupSettingsState);
        }

        // 智能清理开关
        const smartCleanEnabled = document.getElementById('smart-clean-enabled');
        if (smartCleanEnabled) {
            console.log('找到智能清理开关，绑定change事件');
            smartCleanEnabled.removeEventListener('change', updateSmartCleanState);
            smartCleanEnabled.addEventListener('change', updateSmartCleanState);
        }

        console.log('设置面板事件绑定完成');
    } catch (err) {
        console.error('绑定设置面板事件时出错:', err);
        showToast('初始化设置面板失败', 'error');
    }
}

// 立即清理的处理函数
function handleCleanNow() {
    if (confirm('确定要立即执行清理吗？此操作不可撤销。')) {
        cleanupHistory(true);
        updateCleanupPreview();
    }
}

// 更新设置值
function updateSettingsValues() {
    try {
        // 确保设置对象的完整性
        if (!state.settings) {
            state.settings = {
                maxItems: 100,
                keepStarred: true,
                cleanupRules: {
                    enabled: false,
                    interval: 7,
                    maxAge: 30,
                    maxSize: 10,
                    excludeTypes: [],
                    smartClean: {
                        enabled: true,
                        duplicates: true,
                        emptyContent: true,
                        oversizeByType: {
                            text: 1,
                            link: 0.1,
                            image: 5,
                            file: 10
                        }
                    }
                }
            };
        }

        // 获取所有设置元素
        const elements = {
            maxItems: document.getElementById('max-items'),
            keepStarred: document.getElementById('keep-starred'),
            cleanupEnabled: document.getElementById('cleanup-enabled'),
            cleanupInterval: document.getElementById('cleanup-interval'),
            cleanupMaxAge: document.getElementById('cleanup-max-age'),
            cleanupMaxSize: document.getElementById('cleanup-max-size'),
            smartCleanEnabled: document.getElementById('smart-clean-enabled'),
            cleanDuplicates: document.getElementById('clean-duplicates'),
            cleanEmpty: document.getElementById('clean-empty'),
            textSizeLimit: document.getElementById('text-size-limit'),
            linkSizeLimit: document.getElementById('link-size-limit'),
            imageSizeLimit: document.getElementById('image-size-limit'),
            fileSizeLimit: document.getElementById('file-size-limit')
        };

        // 验证所有必需的元素是否存在
        for (const [key, element] of Object.entries(elements)) {
            if (!element) {
                throw new Error(`未找到元素: ${key}`);
            }
        }

        // 回填基本设置
        elements.maxItems.value = state.settings.maxItems || 100;
        elements.keepStarred.checked = state.settings.keepStarred !== false;

        // 回填清理规则设置
        const rules = state.settings.cleanupRules;
        elements.cleanupEnabled.checked = rules.enabled || false;
        elements.cleanupInterval.value = rules.interval || 7;
        elements.cleanupMaxAge.value = rules.maxAge || 30;
        elements.cleanupMaxSize.value = rules.maxSize || 10;

        // 回填排除类型
        const excludeTypes = Array.isArray(rules.excludeTypes) ? rules.excludeTypes : [];
        document.querySelectorAll('.cleanup-type-checkbox').forEach(checkbox => {
            checkbox.checked = !excludeTypes.includes(checkbox.value);
        });

        // 回填智能清理设置
        const smartRules = rules.smartClean;
        elements.smartCleanEnabled.checked = smartRules.enabled || false;
        elements.cleanDuplicates.checked = smartRules.duplicates || false;
        elements.cleanEmpty.checked = smartRules.emptyContent || false;

        // 回填类型大小限制
        const sizeLimits = smartRules.oversizeByType || {};
        elements.textSizeLimit.value = sizeLimits.text || 1;
        elements.linkSizeLimit.value = sizeLimits.link || 0.1;
        elements.imageSizeLimit.value = sizeLimits.image || 5;
        elements.fileSizeLimit.value = sizeLimits.file || 10;

        // 更新设置面板状态
        updateCleanupSettingsState();
        updateSmartCleanState();
        updateCleanupPreview();

        console.log('设置值回填完成');

    } catch (err) {
        console.error('回填设置值时出错:', err);
        showToast('加载设置时出现错误: ' + err.message, 'error');
    }
}

// 更新清理设置面板状态
function updateCleanupSettingsState() {
    try {
        const enabled = document.getElementById('cleanup-enabled').checked;
        const settingsContainer = document.getElementById('cleanup-settings-container');

        if (!settingsContainer) {
            console.error('未找到清理设置容器');
            return;
        }

        settingsContainer.style.opacity = enabled ? '1' : '0.5';
        settingsContainer.style.pointerEvents = enabled ? 'auto' : 'none';

        // 更新状态
        if (state.settings?.cleanupRules) {
            state.settings.cleanupRules.enabled = enabled;
            // 保存设置到本地存储
            saveSettings();

            // 根据启用状态处理自动清理
            if (enabled) {
                startAutoCleanup();
            } else if (cleanupTimer) {
                clearInterval(cleanupTimer);
                cleanupTimer = null;
            }
        }

        // 显示当前配置的影响
        updateCleanupPreview();
    } catch (err) {
        console.error('更新清理设置状态时出错:', err);
        showToast('更新清理设置失败', 'error');
    }
}

// 更新智能清理设置状态
function updateSmartCleanState() {
    const enabled = document.getElementById('smart-clean-enabled').checked;
    const settingsContainer = document.getElementById('smart-clean-settings');
    settingsContainer.style.opacity = enabled ? '1' : '0.5';
    settingsContainer.style.pointerEvents = enabled ? 'auto' : 'none';
    updateCleanupPreview();
}

// 更新清理预览
function updateCleanupPreview() {
    const previewSection = document.getElementById('cleanup-preview');
    if (!previewSection) return;

    // 获取当前设置
    const rules = state.settings.cleanupRules;
    const smartRules = rules.smartClean;

    // 统计信息
    let stats = {
        total: state.clipboardHistory.length,
        toBeRemoved: 0,
        byReason: {
            age: 0,
            size: 0,
            type: 0,
            duplicate: 0,
            empty: 0,
            typeSize: 0
        },
        byType: {
            text: 0,
            link: 0,
            image: 0,
            file: 0
        }
    };

    // 分析每个项目
    const now = new Date();
    const contentMap = new Map();

    state.clipboardHistory.forEach(item => {
        // 跳过置顶项目
        if (state.pinnedItems.has(item.id)) {
            return;
        }

        let willBeRemoved = false;
        const size = new Blob([item.content]).size / (1024 * 1024);

        // 检查基本规则
        const itemDate = new Date(item.timestamp);
        const daysDiff = (now - itemDate) / (1000 * 60 * 60 * 24);

        if (daysDiff > (rules.maxAge || 30)) {
            stats.byReason.age++;
            willBeRemoved = true;
        }

        if (size > (rules.maxSize || 10)) {
            stats.byReason.size++;
            willBeRemoved = true;
        }

        if (rules.excludeTypes.includes(item.type)) {
            stats.byReason.type++;
            willBeRemoved = true;
        }

        // 检查智能清理规则
        if (smartRules.enabled) {
            if (smartRules.emptyContent && (!item.content || item.content.trim() === '')) {
                stats.byReason.empty++;
                willBeRemoved = true;
            }

            if (smartRules.duplicates && contentMap.has(item.content)) {
                stats.byReason.duplicate++;
                willBeRemoved = true;
            }
            contentMap.set(item.content, true);

            const typeLimit = smartRules.oversizeByType[item.type];
            if (typeLimit && size > typeLimit) {
                stats.byReason.typeSize++;
                willBeRemoved = true;
            }
        }

        if (willBeRemoved) {
            stats.toBeRemoved++;
            stats.byType[item.type]++;
        }
    });

    // 生成预览HTML
    let previewHTML = `
        <h4>清理预览</h4>
        <div class="preview-stats">
            <p>总记录数：${stats.total}</p>
            <p>将被清理：${stats.toBeRemoved} 条记录</p>
            
            <div class="preview-details">
                <h5>清理原因统计：</h5>
                <ul>
                    ${stats.byReason.age > 0 ? `<li>超过保留天数：${stats.byReason.age} 条</li>` : ''}
                    ${stats.byReason.size > 0 ? `<li>超过大小限制：${stats.byReason.size} 条</li>` : ''}
                    ${stats.byReason.type > 0 ? `<li>被排除类型：${stats.byReason.type} 条</li>` : ''}
                    ${stats.byReason.duplicate > 0 ? `<li>重复内容：${stats.byReason.duplicate} 条</li>` : ''}
                    ${stats.byReason.empty > 0 ? `<li>空内容：${stats.byReason.empty} 条</li>` : ''}
                    ${stats.byReason.typeSize > 0 ? `<li>超过类型大小限制：${stats.byReason.typeSize} 条</li>` : ''}
                </ul>
                
                <h5>按类型统计：</h5>
                <ul>
                    ${Object.entries(stats.byType)
            .filter(([_, count]) => count > 0)
            .map(([type, count]) => `<li>${getTypeText(type)}：${count} 条</li>`)
            .join('')}
                </ul>
            </div>
        </div>
    `;

    // 添加样式
    const style = `
        <style>
            .preview-stats {
                padding: 10px;
                background: var(--bg-100);
                border-radius: 4px;
            }
            
            .preview-details {
                margin-top: 10px;
                padding: 10px;
                background: var(--bg-200);
                border-radius: 4px;
            }
            
            .preview-details h5 {
                margin: 10px 0 5px;
                color: var(--text-100);
                font-size: 13px;
            }
            
            .preview-details ul {
                margin: 5px 0;
                padding-left: 20px;
                color: var(--text-200);
                font-size: 12px;
            }
            
            .preview-details li {
                margin: 3px 0;
            }
        </style>
    `;

    previewSection.innerHTML = style + previewHTML;
}

// 隐藏设置对话框
function hideSettingsModal() {
    const modal = document.getElementById('settings-modal');
    if (!modal) return;

    // 添加淡出动画
    modal.classList.add('fade-out');
    modal.addEventListener('animationend', () => {
        modal.style.display = 'none';
        modal.classList.remove('fade-out');
        modal.classList.remove('fade-in');
    }, { once: true });
}

// 启动自动清理
let cleanupTimer = null;

function startAutoCleanup() {
    try {
        // 先清除现有的定时器
        if (cleanupTimer) {
            clearInterval(cleanupTimer);
            cleanupTimer = null;
        }

        // 检查清理规则是否启用
        if (!state.settings?.cleanupRules?.enabled) {
            console.log('自动清理未启用');
            return;
        }

        const autoCleanTime = state.settings.cleanupRules.interval;
        if (!autoCleanTime || autoCleanTime <= 0) {
            console.warn('清理间隔无效:', autoCleanTime);
            return;
        }

        console.log('启动自动清理, 间隔:', autoCleanTime, '天');

        // 将天数转换为毫秒
        // const interval = autoCleanTime * 24 * 60 * 60 * 1000;
        // cleanupTimer = setInterval(() => {
        //     try {
        //         cleanupHistory();
        //         saveSettings();
        //         updateClipboardList();
        //         showToast('已执行自动清理');
        //     } catch (err) {
        //         console.error('执行自动清理时出错:', err);
        //         showToast('自动清理执行失败', 'error');
        //     }
        // }, interval);

        // 立即执行一次清理
        cleanupHistory();
        updateClipboardList();
    } catch (err) {
        console.error('启动自动清理时出错:', err);
        showToast('启动自动清理失败', 'error');
    }
}

// 保存设置并关闭
function saveSettingsAndClose() {

}

// 验证设置值
// function validateSettings(settings) {
//     try {
//         // 验证基本设置
//         if (settings.maxItems < 10 || settings.maxItems > 1000) {
//             showToast('最大记录数必须在10-1000之间', 'error');
//             return false;
//         }

//         const rules = settings.cleanupRules;

//         // 验证清理规则
//         if (rules.interval < 1 || rules.interval > 365) {
//             showToast('清理间隔必须在1-365天之间', 'error');
//             return false;
//         }

//         if (rules.maxAge < 1 || rules.maxAge > 365) {
//             showToast('最大保留天数必须在1-365天之间', 'error');
//             return false;
//         }

//         if (rules.maxSize < 1 || rules.maxSize > 100) {
//             showToast('最大文件大小必须在1-100MB之间', 'error');
//             return false;
//         }

//         // 验证类型大小限制
//         const sizeRules = settings.cleanupRules.smartClean.oversizeByType;
//         const sizeValidation = {
//             text: { min: 0.1, max: 10 },
//             link: { min: 0.1, max: 1 },
//             image: { min: 0.1, max: 50 },
//             file: { min: 0.1, max: 100 }
//         };

//         for (const [type, limit] of Object.entries(sizeRules)) {
//             const validation = sizeValidation[type];
//             if (limit < validation.min || limit > validation.max) {
//                 showToast(`${getTypeText(type)}大小限制必须在${validation.min}-${validation.max}MB之间`, 'error');
//                 return false;
//             }
//         }

//         return true;
//     } catch (err) {
//         console.error('验证设置时出错:', err);
//         return false;
//     }
// }

// 执行历史记录清理
function cleanupHistory(isManual = false) {
    try {
        console.log('开始执行清理, 模式:', isManual ? '手动' : '自动');

        // 确保设置对象的完整性
        if (!state.settings?.cleanupRules) {
            console.warn('清理规则未定义，使用默认值');
            state.settings.cleanupRules = {
                enabled: false,
                interval: 7,
                maxAge: 30,
                maxSize: 10,
                excludeTypes: [],
                smartClean: {
                    enabled: true,
                    duplicates: true,
                    emptyContent: true,
                    oversizeByType: {
                        text: 1,
                        link: 0.1,
                        image: 5,
                        file: 10
                    }
                }
            };
        }

        // 如果不是手动清理且自动清理未启用，则返回
        if (!isManual && !state.settings.cleanupRules.enabled) {
            console.log('自动清理未启用，跳过清理');
            return;
        }

        const now = new Date();
        const rules = state.settings.cleanupRules;
        const smartRules = rules.smartClean;

        // 确保excludeTypes数组存在
        if (!Array.isArray(rules.excludeTypes)) {
            rules.excludeTypes = [];
        }

        // 用于检查重复内容的Map
        const contentMap = new Map();
        // 用于记录清理原因的统计
        const cleanupStats = {
            age: 0,
            size: 0,
            type: 0,
            duplicate: 0,
            empty: 0,
            typeSize: 0
        };

        // 创建清理前的备份
        const backupHistory = [...state.clipboardHistory];

        // 过滤历史记录
        const originalLength = state.clipboardHistory.length;
        state.clipboardHistory = state.clipboardHistory.filter(item => {
            try {
                // 保留置顶项目
                if (state.pinnedItems.has(item.id)) {
                    return true;
                }

                // 智能清理规则
                if (smartRules.enabled) {
                    // 清理空内容
                    if (smartRules.emptyContent && (!item.content || item.content.trim() === '')) {
                        cleanupStats.empty++;
                        return false;
                    }

                    // 清理重复内容
                    if (smartRules.duplicates) {
                        const contentKey = item.type === 'image' ?
                            item.content.substring(0, 100) : // 对于图片，只比较前100个字符
                            item.content;

                        if (contentMap.has(contentKey)) {
                            cleanupStats.duplicate++;
                            return false;
                        }
                        contentMap.set(contentKey, true);
                    }

                    // 按类型检查大小限制
                    const size = new Blob([item.content]).size / (1024 * 1024);
                    const typeLimit = smartRules.oversizeByType[item.type];
                    if (typeLimit && size > typeLimit) {
                        cleanupStats.typeSize++;
                        return false;
                    }
                }

                // 基本清理规则
                // 检查保留天数
                const itemDate = new Date(item.timestamp);
                const daysDiff = (now - itemDate) / (1000 * 60 * 60 * 24);
                if (daysDiff > (rules.maxAge || 30)) {
                    cleanupStats.age++;
                    return false;
                }

                // 检查大小限制
                const size = new Blob([item.content]).size / (1024 * 1024);
                if (size > (rules.maxSize || 10)) {
                    cleanupStats.size++;
                    return false;
                }

                // 检查类型排除
                if (rules.excludeTypes.includes(item.type)) {
                    cleanupStats.type++;
                    return false;
                }

                return true;
            } catch (err) {
                console.error('处理剪贴板项目时出错:', err);
                // 出错时保留该项目
                return true;
            }
        });

        // 如果有记录被清理，显示详细统计
        const removedCount = originalLength - state.clipboardHistory.length;
        if (removedCount > 0) {
            const statsMessage = Object.entries(cleanupStats)
                .filter(([_, count]) => count > 0)
                .map(([reason, count]) => {
                    const reasonText = {
                        age: '过期',
                        size: '超大小',
                        type: '排除类型',
                        duplicate: '重复',
                        empty: '空内容',
                        typeSize: '类型大小超限'
                    }[reason];
                    return `${reasonText}: ${count}条`;
                })
                .join('，');

            showToast(`已清理 ${removedCount} 条记录（${statsMessage}）`);

            // 保存更新后的历史记录
            saveSettings();
        } else if (isManual) {
            showToast('没有需要清理的记录');
        }

        // 更新预览
        updateCleanupPreview();

    } catch (err) {
        console.error('清理历史记录时出错:', err);
        showToast('清理过程中出现错误，已还原', 'error');
        // 还原备份
        if (backupHistory) {
            state.clipboardHistory = backupHistory;
        }
    }
}

// 导出历史记录
// function exportHistory() {
//     const data = JSON.stringify(state.clipboardHistory, null, 2);
//     const blob = new Blob([data], { type: 'application/json' });
//     const url = URL.createObjectURL(blob);

//     const a = document.createElement('a');
//     a.href = url;
//     a.download = `clipboard_history_${new Date().toISOString().split('T')[0]}.json`;
//     document.body.appendChild(a);
//     a.click();
//     document.body.removeChild(a);
//     URL.revokeObjectURL(url);

//     showToast('剪贴板历史已导出');
// }

// 提示框功能
function showToast(message, type = 'info') {
    const container = document.getElementById('toast-container');

    // 如果容器不存在，创建一个
    if (!container) {
        const newContainer = document.createElement('div');
        newContainer.id = 'toast-container';
        document.body.appendChild(newContainer);
    }

    // 检查是否已存在相同内容的提示
    const existingToasts = document.getElementsByClassName('toast');
    for (let toast of existingToasts) {
        if (toast.textContent === message) {
            return; // 如果存在相同内容的提示，则不创建新的
        }
    }

    const toast = document.createElement('div');
    toast.className = `toast ${type}`;

    // 根据类型选择图标
    let icon = '';
    switch (type) {
        case 'success':
            icon = '<i class="fas fa-check-circle"></i>';
            break;
        case 'error':
            icon = '<i class="fas fa-times-circle"></i>';
            break;
        default:
            icon = '<i class="fas fa-info-circle"></i>';
    }

    toast.innerHTML = `${icon}${message}`;
    document.getElementById('toast-container').appendChild(toast);

    // 5秒后移除
    setTimeout(() => {
        if (document.getElementById('toast-container').contains(toast)) {
            toast.style.animation = 'fadeOut 0.3s ease forwards';
            toast.addEventListener('animationend', (e) => {
                if (e.animationName === 'fadeOut' &&
                    document.getElementById('toast-container') &&
                    document.getElementById('toast-container').contains(toast)) {
                    document.getElementById('toast-container').removeChild(toast);
                }
            });
        }
    }, 3000);
}

// 复制内容
async function copyContent(id) {
    const item = state.clipboardHistory.find(item => item.id.toString() === id);
    console.log('准备复制内容:', item, state, id);
    if (!item) return;
    try {
        //判断是不是Base64图片
        if (item.type === 'image' && item.content.startsWith('data:image/')) {
            const blob = await fetch(item.content).then(r => r.blob());
            await navigator.clipboard.write([new ClipboardItem({ 'image/png': blob })]);
        } else {
            await navigator.clipboard.writeText(item.content);
        }
        showToast('复制成功');
    } catch (err) {
        console.error('复制失败:', err);
        showToast('复制失败，请重新复制。', 'error');
        const textarea = document.createElement('textarea');
        textarea.value = item.content;
        document.body.appendChild(textarea);
        textarea.select();
        document.execCommand('copy'); //可能被某些浏览器禁用 (#)
        document.body.removeChild(textarea);
    }
}

// 开始编辑
function startEditing(id) {
    const item = state.clipboardHistory.find(item => item.id.toString() === id);
    if (!item) return;

    state.editingItem = item;
    const previewSection = document.getElementById('clipboard-preview');
    const previewContent = previewSection.querySelector('.preview-content');
    const previewEditor = previewSection.querySelector('.preview-editor');

    // 切换到编辑模式
    previewContent.style.display = 'none';
    previewEditor.style.display = 'flex';

    // 填充编辑器
    const textarea = document.getElementById('edit-clipboard-content');
    textarea.value = item.content;

    // 根据内容类型设置编辑器样式
    textarea.className = `editor-${item.type}`;

    // 添加自动保存监听
    const autoSave = document.getElementById('auto-save');
    if (autoSave.checked) {
        textarea.addEventListener('input', debounce(saveEdit, 1000));
    }
}

// 保存编辑
function saveEdit() {
    if (!state.editingItem) return;

    const content = document.getElementById('edit-clipboard-content').value;
    if (!content) {
        showToast('内容不能为空', 'error');
        return;
    }

    state.editingItem.content = content;
    state.editingItem.type = detectContentType(content);
    state.editingItem.size = getContentSize(content);
    state.editingItem.timestamp = new Date().toISOString();

    saveSettings();
    updateClipboardList();
    updatePreview(state.editingItem);

    // 退出编辑模式
    exitEditing();

    showToast('保存成功');
}

// 退出编辑
function exitEditing() {
    state.editingItem = null;
    const previewSection = document.getElementById('clipboard-preview');
    const previewContent = previewSection.querySelector('.preview-content');
    const previewEditor = previewSection.querySelector('.preview-editor');

    previewContent.style.display = 'block';
    previewEditor.style.display = 'none';

    // 移除自动保存监听
    const textarea = document.getElementById('edit-clipboard-content');
    textarea.className = '';
    textarea.value = '';
}

// 切换置顶状态
function togglePin(id) {
    const numId = parseInt(id);
    if (state.pinnedItems.has(numId)) {
        state.pinnedItems.delete(numId);
        state.clipboardHistory.find(item => item.id === numId).starred = false;
        showToast('已取消置顶');
    } else {
        state.pinnedItems.add(numId);
        //改变数据starred的值
        state.clipboardHistory.find(item => item.id === numId).starred = true;
        showToast('已置顶');
    }

    saveSettings();
    updateClipboardList();
}

// 删除内容
function deleteContent(id) {
    const item = state.clipboardHistory.find(item => item.id.toString() === id);
    if (!item) return;

    const isPinned = state.pinnedItems.has(item.id);
    const message = isPinned ? '确定要删除这条置顶记录吗？' : '确定要删除这条记录吗？';

    if (confirm(message)) {
        state.clipboardHistory = state.clipboardHistory.filter(i => i.id !== item.id);
        state.pinnedItems.delete(item.id);

        if (state.selectedItem?.id === item.id) {
            state.selectedItem = null;
        }

        saveSettings();
        updateClipboardList();

        showToast('删除成功');
    }
}

// 防抖函数
function debounce(func, wait) {
    let timeout;
    return function executedFunction(...args) {
        const later = () => {
            clearTimeout(timeout);
            func(...args);
        };
        clearTimeout(timeout);
        timeout = setTimeout(later, wait);
    };
}

// 格式化文本内容
function formatEditContent() {
    if (!state.editingItem) return;

    const textarea = document.getElementById('edit-clipboard-content');
    let content = textarea.value;

    try {
        switch (state.editingItem.type) {
            case 'json':
                // JSON格式化
                content = JSON.stringify(JSON.parse(content), null, 2);
                break;
            case 'html':
                // HTML格式化
                content = formatHTML(content);
                break;
            case 'code':
                // 代码缩进格式化
                content = formatCode(content);
                break;
            default:
                // 普通文本格式化：去除多余空格和空行
                content = content.replace(/\s+/g, ' ').trim();
        }
        textarea.value = content;
        showToast('格式化成功');
    } catch (err) {
        console.error('格式化失败:', err);
        showToast('格式化失败，请检查内容格式', 'error');
    }
}

// HTML格式化
function formatHTML(html) {
    let formatted = '';
    let indent = 0;

    // 分割HTML标签和文本
    const tokens = html.replace(/>\s+</g, '><')
        .replace(/</g, '~<')
        .replace(/>/g, '>~')
        .split('~');

    tokens.forEach(token => {
        if (!token) return;

        if (token.startsWith('</')) {
            indent--;
            formatted += '  '.repeat(indent) + token + '\n';
        } else if (token.startsWith('<')) {
            formatted += '  '.repeat(indent) + token + '\n';
            if (!token.startsWith('</')
                && !token.endsWith('/>')
                && !token.startsWith('<!')) {
                indent++;
            }
        } else {
            formatted += '  '.repeat(indent) + token.trim() + '\n';
        }
    });

    return formatted.trim();
}

// 代码格式化
function formatCode(code) {
    let formatted = '';
    let indent = 0;
    const lines = code.split('\n');

    lines.forEach(line => {
        const trimmedLine = line.trim();

        // 减少缩进的情况
        if (trimmedLine.startsWith('}')
            || trimmedLine.startsWith(']')
            || trimmedLine.startsWith(')')) {
            indent = Math.max(0, indent - 1);
        }

        // 添加当前行
        if (trimmedLine.length > 0) {
            formatted += '  '.repeat(indent) + trimmedLine + '\n';
        }

        // 增加缩进的情况
        if (trimmedLine.endsWith('{')
            || trimmedLine.endsWith('[')
            || trimmedLine.endsWith('(')) {
            indent++;
        }
    });

    return formatted.trim();
}

// 清除编辑内容
function clearEditContent() {
    const textarea = document.getElementById('edit-clipboard-content');
    if (confirm('确定要清除所有内容吗？')) {
        textarea.value = '';
        showToast('内容已清除');
    }
}

// 初始化事件监听
function initializeEventListeners() {
    // 自动监听开关
    document.getElementById('auto-monitor-toggle').addEventListener('change', (e) => {
        state.settings.autoMonitor = e.target.checked;
        saveSettings();
        if (e.target.checked) {
            startClipboardMonitor();
        } else {
            stopClipboardMonitor();
        }
    });

    // 搜索框
    document.getElementById('search-clipboard').addEventListener('input', (e) => {
        state.searchTerm = e.target.value.toLowerCase();
        updateClipboardList();

        // 确保输入操作不会导致页面失去焦点
        isPageFocused = true;
    });

    // 类型过滤器
    document.querySelectorAll('.type-filter').forEach(button => {
        button.addEventListener('click', () => {
            document.querySelector('.type-filter.active').classList.remove('active');
            button.classList.add('active');
            state.currentFilter = button.dataset.type;
            updateClipboardList();

            // 确保菜单切换不会导致页面失去焦点
            setTimeout(() => {
                isPageFocused = true;
            }, 100);
        });
    });

    // 刷新按钮
    document.getElementById('refresh-clipboard').addEventListener('click', () => {
        updateClipboardList();

        // 确保按钮点击不会导致页面失去焦点
        isPageFocused = true;
        showToast('已刷新剪贴板历史');

    });

    // 清空按钮
    document.getElementById('clear-clipboard').addEventListener('click', () => {
        if (confirm('确定要清空剪贴板记录吗？将保留最新的100条记录和所有置顶记录')) {
            // 保留置顶记录
            const pinnedItems = state.clipboardHistory.filter(item => state.pinnedItems.has(item.id));
            
            // 获取非置顶记录并按时间戳降序排序
            const unpinnedItems = state.clipboardHistory
                .filter(item => !state.pinnedItems.has(item.id))
                .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
            
            // 保留最新的100条非置顶记录
            const latestUnpinnedItems = unpinnedItems.slice(0, 100);
            
            // 合并置顶记录和最新的非置顶记录
            state.clipboardHistory = [...pinnedItems, ...latestUnpinnedItems];
            //更新本地存储
            localStorage.setItem('clipboard_history', JSON.stringify(state.clipboardHistory));
            
            updateClipboardList();
            showToast('已清理剪贴板历史，保留了置顶记录和最新的100条记录');
        }

        // 确保对话框关闭后不会导致页面失去焦点
        setTimeout(() => {
            // isPageFocused = true;
            // 尝试聚焦当前页面
            window.focus();
            // 或者模拟用户交互（部分浏览器可能限制非用户触发的 focus）
            document.body.focus(); // 聚焦到 body
            document.getElementById('search-clipboard').focus(); // 聚焦到刷新按钮

        }, 100);
    });

    // 清理策略设置
    // document.getElementById('clear-settings').addEventListener('click', () => {
    //     showSettingsModal();
    //     // 确保打开设置对话框不会导致页面失去焦点
    //     setTimeout(() => {
    //         isPageFocused = true;
    //     }, 100);
    // });

    document.getElementById('save-settings').addEventListener('click', () => {
        saveSettingsAndClose();
        // 确保保存设置后不会导致页面失去焦点
        setTimeout(() => {
            isPageFocused = true;
        }, 100);
    });

    document.getElementById('cancel-settings').addEventListener('click', () => {
        hideSettingsModal();
        // 确保关闭设置对话框不会导致页面失去焦点
        setTimeout(() => {
            isPageFocused = true;
        }, 100);
    });

    // // 返回按钮
    // document.querySelector('.back-button').addEventListener('click', () => {
    //     window.history.back();
    // });

    // 编辑器工具栏按钮
    document.getElementById('format-content').addEventListener('click', formatEditContent);
    document.getElementById('clear-content').addEventListener('click', clearEditContent);
    document.getElementById('save-edit').addEventListener('click', saveEdit);
    document.getElementById('cancel-edit').addEventListener('click', exitEditing);

    // 自动保存开关
    document.getElementById('auto-save').addEventListener('change', (e) => {
        const textarea = document.getElementById('edit-clipboard-content');
        if (e.target.checked) {
            textarea.addEventListener('input', debounce(saveEdit, 1000));
        } else {
            textarea.removeEventListener('input', debounce(saveEdit, 1000));
        }
    });
}

// 启动剪贴板监听
if (state.settings.autoMonitor) {
    startClipboardMonitor();
}

// 更新设置值时的输入验证
// function validateSettingsInput(input, min, max) {
//     const value = parseFloat(input.value);
//     if (isNaN(value) || value < min || value > max) {
//         input.classList.add('invalid-input');
//         setTimeout(() => input.classList.remove('invalid-input'), 500);
//         return false;
//     }
//     return true;
// }

// 导出模块
module.exports = {
    initialize
};